import { ref, reactive, onUnmounted } from 'vue'
import DEFAULT_CONFIG from '@/config/index.js'

/**
 * 多会话 SSE 聊天管理
 * 支持多个会话并发执行，每个会话独立管理
 */
export function createMultiSessionChat() {
  // 会话状态管理 Map<chatId, sessionState>
  const sessions = reactive(new Map())
  
  // 当前激活的会话ID
  const activeChatId = ref(null)
  
  // 获取SSE接口地址
  const getSSEBaseUrl = () => {
    try {
      const aiSettings = localStorage.getItem('aiSettings')
      if (aiSettings) {
        const config = JSON.parse(aiSettings)
        if (config.sseUrl) {
          return config.sseUrl
        }
      }
    } catch (error) {
      console.error('加载AI设置失败:', error)
    }
    return DEFAULT_CONFIG.REMOTE_URL || 'http://localhost:1818'
  }

  // 安全地设置 ref 值（辅助函数）
  const safeSetRef = (refObj, value) => {
    if (!refObj || typeof refObj !== 'object' || refObj === null || !('value' in refObj)) {
      // 如果不是 ref，创建一个新的 ref
      return ref(value)
    }
    refObj.value = value
    return refObj
  }

  // 安全地获取 ref 值（辅助函数）
  const safeGetRef = (refObj, defaultValue = false) => {
    if (!refObj || typeof refObj !== 'object' || refObj === null || !('value' in refObj)) {
      return defaultValue
    }
    return refObj.value
  }

  // 确保会话属性是 ref（辅助函数）
  const ensureSessionRefs = (session) => {
    if (!session) return
    
    // 确保 messages 是 ref
    if (!session.messages || 
        typeof session.messages !== 'object' || 
        session.messages === null ||
        !('value' in session.messages) ||
        Array.isArray(session.messages)) {
      const defaultMessages = [
        {
          id: Date.now(),
          role: 'assistant',
          content: '你好！我是AI助手，有什么可以帮你的吗？',
          timestamp: Date.now()
        }
      ]
      // 如果 session.messages 是数组，使用它；否则使用默认值
      const initialMessages = Array.isArray(session.messages) ? session.messages : defaultMessages
      session.messages = ref(initialMessages)
    }
    
    // 确保 messages.value 是数组
    if (!Array.isArray(session.messages.value)) {
      session.messages.value = [
        {
          id: Date.now(),
          role: 'assistant',
          content: '你好！我是AI助手，有什么可以帮你的吗？',
          timestamp: Date.now()
        }
      ]
    }
    
    // 确保 loading 是 ref（检查是否是 ref 对象，而不是布尔值或其他类型）
    // 如果 loading 不存在、不是对象、是 null、或者是布尔值，都需要创建 ref
    if (!session.loading || 
        typeof session.loading !== 'object' || 
        session.loading === null ||
        !('value' in session.loading)) {
      // 如果当前值是布尔值，保留它；否则使用 false
      const currentValue = (typeof session.loading === 'boolean') ? session.loading : false
      session.loading = ref(currentValue)
    }
    
    // 确保 connected 是 ref（检查是否是 ref 对象，而不是布尔值或其他类型）
    // 如果 connected 不存在、不是对象、是 null、或者是布尔值，都需要创建 ref
    if (!session.connected || 
        typeof session.connected !== 'object' || 
        session.connected === null ||
        !('value' in session.connected)) {
      // 如果当前值是布尔值，保留它；否则使用 false
      const currentValue = (typeof session.connected === 'boolean') ? session.connected : false
      session.connected = ref(currentValue)
    }
  }

  // 获取或创建会话状态
  const getOrCreateSession = (chatId) => {
    if (!sessions.has(chatId)) {
      const newSession = {
        chatId,
        messages: ref([
          {
            id: Date.now(),
            role: 'assistant',
            content: '你好！我是AI助手，有什么可以帮你的吗？',
            timestamp: Date.now()
          }
        ]),
        loading: ref(false),
        connected: ref(false),
        eventSource: null,
        timeoutId: null,
        updateTimer: null // 用于防抖更新，避免频繁触发响应式更新
      }
      sessions.set(chatId, newSession)
      return newSession
    }
    const session = sessions.get(chatId)
    // 确保所有属性都是 ref
    ensureSessionRefs(session)
    return session
  }

  // 关闭会话连接
  const closeSessionConnection = (chatId) => {
    const session = sessions.get(chatId)
    if (!session) return

    // 确保属性是 ref
    ensureSessionRefs(session)

    // 清除超时定时器
    if (session.timeoutId) {
      clearTimeout(session.timeoutId)
      session.timeoutId = null
    }
    
    // 清除更新定时器
    if (session.updateTimer) {
      clearTimeout(session.updateTimer)
      session.updateTimer = null
    }

    // 关闭 SSE 连接
    if (session.eventSource) {
      session.eventSource.close()
      session.eventSource = null
      // 使用安全设置函数
      session.connected = safeSetRef(session.connected, false)
    }
  }

  // 发送消息（为指定会话）
  const sendMessage = (message, chatId) => {
    if (!message || !message.trim() || !chatId) {
      return
    }

    const session = getOrCreateSession(chatId)
    // getOrCreateSession 已经确保了所有属性都是 ref
    
    // 再次确保所有属性都是 ref（防御性编程）
    ensureSessionRefs(session)
    
    // 确保 messages.value 是数组
    if (!Array.isArray(session.messages.value)) {
      session.messages.value = [
        {
          id: Date.now(),
          role: 'assistant',
          content: '你好！我是AI助手，有什么可以帮你的吗？',
          timestamp: Date.now()
        }
      ]
    }
    
    // 确保 loading 是 ref（防御性检查）
    if (!session.loading || typeof session.loading !== 'object' || !('value' in session.loading)) {
      const currentValue = typeof session.loading === 'boolean' ? session.loading : false
      session.loading = ref(currentValue)
    }
    
    // 如果该会话正在加载，不允许发送新消息
    if (safeGetRef(session.loading, false)) {
      console.warn(`会话 ${chatId} 正在处理消息，请稍候...`)
      return
    }

    // 关闭该会话之前的连接
    closeSessionConnection(chatId)

    // 添加用户消息
    const userMessage = {
      id: Date.now(),
      role: 'user',
      content: message.trim(),
      timestamp: Date.now(),
      isNew: true
    }
    session.messages.value.push(userMessage)
    // 触发响应式更新
    session.messages.value = [...session.messages.value]

    // 500ms 后移除 isNew 标记
    setTimeout(() => {
      const lastMsg = session.messages.value[session.messages.value.length - 1]
      if (lastMsg && lastMsg.role === 'user') {
        delete lastMsg.isNew
        // 触发响应式更新
        session.messages.value = [...session.messages.value]
      }
    }, 500)

    // 设置加载状态（使用安全设置函数）
    session.loading = safeSetRef(session.loading, true)

    // 构建SSE URL
    const baseUrl = getSSEBaseUrl()
    const query = encodeURIComponent(message.trim())
    const sseUrl = `${baseUrl}/hello/stream/chat2?query=${query}&chat-id=${chatId}`

    console.log(`会话 ${chatId} 连接SSE:`, sseUrl)

    try {
      // 确保 messages.value 是数组
      if (!Array.isArray(session.messages.value)) {
        session.messages.value = []
      }
      
      // 创建新的助手消息（用于流式接收）
      const assistantMessage = {
        id: Date.now(),
        role: 'assistant',
        content: '',
        timestamp: Date.now(),
        isNew: true
      }
      session.messages.value.push(assistantMessage)
      // Vue 3 会自动检测到数组 push 操作，不需要重新赋值

      // 流式接收完成后移除 isNew 标记
      const removeNewFlag = () => {
        setTimeout(() => {
          if (assistantMessage) {
            delete assistantMessage.isNew
            // Vue 3 会自动检测到对象属性的删除，不需要重新赋值
          }
        }, 500)
      }

      // 创建 EventSource 连接
      const eventSource = new EventSource(sseUrl)
      session.eventSource = eventSource
      session.connected = safeSetRef(session.connected, true)

      // 连接打开
      eventSource.onopen = () => {
        console.log(`会话 ${chatId} SSE连接已建立`)
        session.connected = safeSetRef(session.connected, true)
      }

      // 接收消息
      eventSource.onmessage = (event) => {
        try {
          let data = event.data

          if (!data || data.trim() === '') {
            return
          }

          // SSE 数据格式可能是 "data: xxx" 格式
          if (data.startsWith('data: ')) {
            data = data.substring(6)
          }

          // 尝试解析JSON
          let parsedData = null
          try {
            parsedData = JSON.parse(data)
          } catch (e) {
            parsedData = null
          }

          // 获取最后的助手消息
          const lastMsg = session.messages.value[session.messages.value.length - 1]
          if (!lastMsg || lastMsg.role !== 'assistant') {
            return
          }

          // 处理不同类型的消息
          if (parsedData) {
            if (parsedData.content !== undefined) {
              lastMsg.content += parsedData.content || ''
            } else if (parsedData.messageType) {
              handleStructuredMessage(parsedData, lastMsg, session, removeNewFlag)
            } else if (parsedData.text) {
              lastMsg.content += parsedData.text || ''
            } else if (parsedData.message) {
              lastMsg.content += parsedData.message || ''
            } else {
              lastMsg.content += data
            }
          } else {
            lastMsg.content += data
          }

          // 触发响应式更新：使用防抖，避免频繁更新
          if (!session.updateTimer) {
            session.updateTimer = setTimeout(() => {
              // 通过重新赋值触发响应式更新
              const currentMessages = session.messages.value
              session.messages.value = [...currentMessages]
              session.updateTimer = null
            }, 100) // 100ms 防抖
          }
        } catch (error) {
          console.error(`会话 ${chatId} 处理SSE消息失败:`, error)
        }
      }

      // 处理错误
      eventSource.onerror = (error) => {
        console.error(`会话 ${chatId} SSE连接错误:`, error)
        session.connected = safeSetRef(session.connected, false)
        session.loading = safeSetRef(session.loading, false)

        if (session.timeoutId) {
          clearTimeout(session.timeoutId)
          session.timeoutId = null
        }

        if (eventSource && eventSource.readyState === EventSource.CLOSED) {
          const lastMsg = session.messages.value[session.messages.value.length - 1]
          if (lastMsg && lastMsg.role === 'assistant' && !lastMsg.content) {
            lastMsg.content = '连接已关闭，请重试'
            lastMsg.isError = true
            // Vue 3 会自动检测到对象属性的变化
          }
        }

        removeNewFlag()
        closeSessionConnection(chatId)
      }

      // 监听自定义事件
      eventSource.addEventListener('end', (event) => {
        console.log(`会话 ${chatId} SSE流结束`, event)
        if (session.timeoutId) {
          clearTimeout(session.timeoutId)
          session.timeoutId = null
        }
        session.loading = safeSetRef(session.loading, false)
        removeNewFlag()
        closeSessionConnection(chatId)
      })

      eventSource.addEventListener('close', (event) => {
        console.log(`会话 ${chatId} SSE连接关闭`, event)
        if (session.timeoutId) {
          clearTimeout(session.timeoutId)
          session.timeoutId = null
        }
        session.loading = safeSetRef(session.loading, false)
        removeNewFlag()
        closeSessionConnection(chatId)
      })

      eventSource.addEventListener('error', (event) => {
        console.error(`会话 ${chatId} SSE错误事件:`, event)
        if (session.timeoutId) {
          clearTimeout(session.timeoutId)
          session.timeoutId = null
        }
        session.loading = safeSetRef(session.loading, false)
        const lastMsg = session.messages.value[session.messages.value.length - 1]
        if (lastMsg && lastMsg.role === 'assistant') {
          if (!lastMsg.content) {
            lastMsg.content = `错误：${event.data || '连接错误'}`
            lastMsg.isError = true
            // Vue 3 会自动检测到对象属性的变化
          }
        }
        removeNewFlag()
        closeSessionConnection(chatId)
      })

      // 设置超时
      session.timeoutId = setTimeout(() => {
        if (safeGetRef(session.loading, false) && session.eventSource) {
          console.warn(`会话 ${chatId} SSE连接超时，自动关闭`)
          session.loading = safeSetRef(session.loading, false)
          const lastMsg = session.messages.value[session.messages.value.length - 1]
          if (lastMsg && lastMsg.role === 'assistant' && !lastMsg.content.trim()) {
            lastMsg.content = '响应超时，请重试'
            lastMsg.isError = true
            // Vue 3 会自动检测到对象属性的变化
          }
          removeNewFlag()
          closeSessionConnection(chatId)
        }
      }, 60000)

    } catch (error) {
      console.error(`会话 ${chatId} 创建SSE连接失败:`, error)
      // 使用安全设置函数
      session.loading = safeSetRef(session.loading, false)
      session.connected = safeSetRef(session.connected, false)
      const lastMsg = session.messages.value[session.messages.value.length - 1]
      if (lastMsg && lastMsg.role === 'assistant') {
        lastMsg.content = `连接失败：${error.message}`
        lastMsg.isError = true
        // Vue 3 会自动检测到对象属性的变化
      }
    }
  }

  // 处理结构化消息
  const handleStructuredMessage = (parsedData, assistantMessage, session, removeNewFlag) => {
    const { messageType, content, error } = parsedData

    // 确保 session 的属性是 ref
    ensureSessionRefs(session)

    switch (messageType) {
      case 'content':
        if (content && content !== '') {
          assistantMessage.content += content || ''
        }
        break
      case 'reasoning':
        if (content && content !== '') {
          assistantMessage.content += content || ''
        }
        break
      case 'over':
      case 'end':
        console.log(`会话 ${session.chatId} 消息接收完成`)
        if (session.timeoutId) {
          clearTimeout(session.timeoutId)
          session.timeoutId = null
        }
        session.loading = safeSetRef(session.loading, false)
        if (removeNewFlag) removeNewFlag()
        closeSessionConnection(session.chatId)
        break
      case 'error':
        console.error(`会话 ${session.chatId} 接收到错误消息:`, error)
        if (session.timeoutId) {
          clearTimeout(session.timeoutId)
          session.timeoutId = null
        }
        session.loading = safeSetRef(session.loading, false)
        assistantMessage.content = `错误：${error || '未知错误'}`
        assistantMessage.isError = true
        if (removeNewFlag) removeNewFlag()
        closeSessionConnection(session.chatId)
        break
      default:
        if (content) {
          assistantMessage.content += content
        }
    }
  }

  // 设置会话消息
  const setSessionMessages = (chatId, newMessages) => {
    const session = getOrCreateSession(chatId)
    // getOrCreateSession 已经确保了所有属性都是 ref
    
    if (Array.isArray(newMessages)) {
      // 确保每条消息都有 id
      const messagesWithId = newMessages.map((msg, index) => {
        if (!msg.id) {
          msg.id = msg.timestamp || Date.now() + index
        }
        return msg
      })
      session.messages.value = JSON.parse(JSON.stringify(messagesWithId))
    }
  }

  // 获取会话消息
  const getSessionMessages = (chatId) => {
    const session = sessions.get(chatId)
    if (!session) return []
    ensureSessionRefs(session)
    return session.messages.value
  }

  // 获取会话加载状态
  const getSessionLoading = (chatId) => {
    const session = sessions.get(chatId)
    if (!session) return false
    ensureSessionRefs(session)
    return safeGetRef(session.loading, false)
  }

  // 设置激活会话
  const setActiveChatId = (chatId) => {
    activeChatId.value = chatId
  }

  // 获取当前激活会话的消息
  const getActiveMessages = () => {
    if (!activeChatId.value) return ref([])
    const session = sessions.get(activeChatId.value)
    if (!session) return ref([])
    ensureSessionRefs(session)
    return session.messages
  }

  // 获取当前激活会话的加载状态
  const getActiveLoading = () => {
    if (!activeChatId.value) return ref(false)
    const session = sessions.get(activeChatId.value)
    if (!session) return ref(false)
    ensureSessionRefs(session)
    return session.loading
  }

  // 删除会话
  const deleteSession = (chatId) => {
    closeSessionConnection(chatId)
    sessions.delete(chatId)
    if (activeChatId.value === chatId) {
      activeChatId.value = null
    }
  }

  // 组件卸载时清理所有会话
  onUnmounted(() => {
    sessions.forEach((session, chatId) => {
      closeSessionConnection(chatId)
    })
    sessions.clear()
  })

  return {
    sendMessage,
    setSessionMessages,
    getSessionMessages,
    getSessionLoading,
    setActiveChatId,
    getActiveMessages,
    getActiveLoading,
    deleteSession,
    activeChatId,
    sessions,
    ensureSessionRefs
  }
}

